﻿#include "pl_processdatamanager.h"
#include "qdebug.h"

PL_ProcessDataManager::PL_ProcessDataManager(QObject *parent)
    : QObject{parent}
{}

bool PL_ProcessDataManager::isExistTable()
{
    PL_ProcessDB Db;

    QString sql = "SELECT ID, LeftAngle,RightAngle,LG_VALUE,LC_VALUE,Count FROM PL_ProcessDB;";

    bool ok = Db.execSql(sql);
    if(!ok)
    {
        qDebug()<<"Cpp:不存在数据库表 PL_ProcessDB";

        sql = "CREATE TABLE PL_ProcessDB (ID INTEGER PRIMARY KEY ,LeftAngle TEXT,RightAngle TEXT,LG_VALUE TEXT,LC_VALUE TEXT,Count TEXT);";
        qDebug()<<"Cpp:创建数据表 PL_ProcessDB sql:"<<sql;
        bool ok = Db.execSql(sql);
        if(ok)
        {
            qDebug()<<"Cpp:创建数据表 PL_ProcessDB 成功";

            for(int i = 0 ; i < 20* 20; i++)
            {
                addData();
            }

            for(int i =0 ;i < 20*20; i++)
            {
                saveData((i+1),"LeftAngle","45");
                saveData((i+1),"RightAngle","45");
                saveData((i+1),"LG_VALUE","0");
                saveData((i+1),"LC_VALUE","0");
                saveData((i+1),"Count","0");
            }
        }
        else
        {
            qDebug()<<"Cpp:创建数据表 PL_ProcessDB 失败";
            return false;
        }
    }
    else
    {
        getParameterByPacket(0);
    }

    return true;
}

void PL_ProcessDataManager::getAllParameterFromSQL()
{
    PL_ProcessDB Db;

    QSharedPointer<QSqlQuery> result;

    QString sql = "SELECT ID, LeftAngle,RightAngle,LG_VALUE,LC_VALUE,Count FROM PL_ProcessDB ;";

    QString leftAngle;
    QString rightAngle;
    QString lg_Value;
    QString lc_Value;
    QString count;

    result.reset(Db.execSql_result(sql));
    if(!result.isNull())
    {
        while(result->next())
        {

            int id = result->value(0).toInt();

            switch(id)
            {
            case 1:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                // setLeftAngle01(leftAngle);
                // setRightAngle01(rightAngle);
                // setLG_Value01(lg_Value);
                // setLC_Value01(lc_Value);
                // setCount01(count);
                // qDebug()<<"左角度: "<<leftAngle;
                // qDebug()<<"右角度: "<<rightAngle;
                // qDebug()<<"料高: "<<lg_Value;
                // qDebug()<<"料长: "<<lc_Value;
                // qDebug()<<"总数: "<<count;

                break;
            case 2 :
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 3:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 4:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 5:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 6:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 7:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 8:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 9:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 10:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 11:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 12:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 13:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 14:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 15:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 16:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 17:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 18:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 19:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            case 20:
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();
                break;
            default:
                break;
            }

        }


        result.clear();
    }
}

void PL_ProcessDataManager::getParameterByPacket(int packetNumber )
{
    PL_ProcessDB Db;

    QSharedPointer<QSqlQuery> result;


    int downlimit = (packetNumber * 20 + 1);

    int uplimit = (packetNumber * 20 + 20);

    QString sql = QString("SELECT ID, LeftAngle,RightAngle,LG_VALUE,LC_VALUE,Count FROM PL_ProcessDB WHERE ID BETWEEN %1 AND %2 ;").arg(downlimit).arg(uplimit);

    QString leftAngle;
    QString rightAngle;
    QString lg_Value;
    QString lc_Value;
    QString count;

    result.reset(Db.execSql_result(sql));

    if(!result.isNull())
    {
        while(result->next())
        {
            int id = result->value(0).toInt();

            if(id == downlimit )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle01(leftAngle);
                setRightAngle01(rightAngle);
                setLG_Value01(lg_Value);
                setLC_Value01(lc_Value);
                setCount01(count);

            }
            else if(id == (downlimit + 1) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle02(leftAngle);
                setRightAngle02(rightAngle);
                setLG_Value02(lg_Value);
                setLC_Value02(lc_Value);
                setCount02(count);
            }
            else if(id == (downlimit + 2) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle03(leftAngle);
                setRightAngle03(rightAngle);
                setLG_Value03(lg_Value);
                setLC_Value03(lc_Value);
                setCount03(count);
            }
            else if(id == (downlimit + 3) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle04(leftAngle);
                setRightAngle04(rightAngle);
                setLG_Value04(lg_Value);
                setLC_Value04(lc_Value);
                setCount04(count);
            }
            else if(id == (downlimit + 4) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle05(leftAngle);
                setRightAngle05(rightAngle);
                setLG_Value05(lg_Value);
                setLC_Value05(lc_Value);
                setCount05(count);
            }
            else if(id == (downlimit + 5))
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle06(leftAngle);
                setRightAngle06(rightAngle);
                setLG_Value06(lg_Value);
                setLC_Value06(lc_Value);
                setCount06(count);
            }
            else if(id == (downlimit + 6) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle07(leftAngle);
                setRightAngle07(rightAngle);
                setLG_Value07(lg_Value);
                setLC_Value07(lc_Value);
                setCount07(count);
            }
            else if(id == (downlimit + 7) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle08(leftAngle);
                setRightAngle08(rightAngle);
                setLG_Value08(lg_Value);
                setLC_Value08(lc_Value);
                setCount08(count);
            }
            else if(id == (downlimit + 8) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle09(leftAngle);
                setRightAngle09(rightAngle);
                setLG_Value09(lg_Value);
                setLC_Value09(lc_Value);
                setCount09(count);
            }
            else if(id == (downlimit + 9))
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle10(leftAngle);
                setRightAngle10(rightAngle);
                setLG_Value10(lg_Value);
                setLC_Value10(lc_Value);
                setCount10(count);
            }
            else if(id == (downlimit + 10) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle11(leftAngle);
                setRightAngle11(rightAngle);
                setLG_Value11(lg_Value);
                setLC_Value11(lc_Value);
                setCount11(count);
            }
            else if(id == (downlimit + 11))
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle12(leftAngle);
                setRightAngle12(rightAngle);
                setLG_Value12(lg_Value);
                setLC_Value12(lc_Value);
                setCount12(count);
            }
            else if(id == (downlimit + 12) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle13(leftAngle);
                setRightAngle13(rightAngle);
                setLG_Value13(lg_Value);
                setLC_Value13(lc_Value);
                setCount13(count);
            }
            else if(id == (downlimit + 13) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle14(leftAngle);
                setRightAngle14(rightAngle);
                setLG_Value14(lg_Value);
                setLC_Value14(lc_Value);
                setCount14(count);
            }
            else if(id == (downlimit + 14) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle15(leftAngle);
                setRightAngle15(rightAngle);
                setLG_Value15(lg_Value);
                setLC_Value15(lc_Value);
                setCount15(count);
            }
            else if(id == (downlimit + 15) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle16(leftAngle);
                setRightAngle16(rightAngle);
                setLG_Value16(lg_Value);
                setLC_Value16(lc_Value);
                setCount16(count);
            }
            else if(id == (downlimit + 16) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle17(leftAngle);
                setRightAngle17(rightAngle);
                setLG_Value17(lg_Value);
                setLC_Value17(lc_Value);
                setCount17(count);
            }
            else if(id == (downlimit + 17) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle18(leftAngle);
                setRightAngle18(rightAngle);
                setLG_Value18(lg_Value);
                setLC_Value18(lc_Value);
                setCount18(count);
            }
            else if(id == (downlimit + 18) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle19(leftAngle);
                setRightAngle19(rightAngle);
                setLG_Value19(lg_Value);
                setLC_Value19(lc_Value);
                setCount19(count);
            }
            else if(id == (downlimit + 19) )
            {
                leftAngle = result->value(1).toString();
                rightAngle = result->value(2).toString();
                lg_Value = result->value(3).toString();
                lc_Value = result->value(4).toString();
                count = result->value(5).toString();

                setLeftAngle20(leftAngle);
                setRightAngle20(rightAngle);
                setLG_Value20(lg_Value);
                setLC_Value20(lc_Value);
                setCount20(count);
            }
        }
    }

}

void PL_ProcessDataManager::addData()
{
    PL_ProcessDB Db;

    QString sql = "INSERT INTO PL_ProcessDB (LeftAngle , RightAngle , LG_VALUE , LC_VALUE , Count) VALUES('','','','','')";

    qDebug()<<"Cpp:插入数据 sql:"<<sql;

    bool ok = Db.execSql(sql);
    if(!ok)
    {
        qDebug()<<"Cpp:添加数据失败";
    }
    else
    {
        qDebug()<<"Cpp:添加数据成功";
        getAllParameterFromSQL();
    }
}

void PL_ProcessDataManager::saveData(int id, QString key, QString value)
{
    PL_ProcessDB Db;

    QString sql = "UPDATE PL_ProcessDB SET " + key + "='"+ value +"' WHERE ID = "+QString::number(id);

    qDebug()<<"Cpp:更新数据 sql:"<<sql;

    bool ok = Db.execSql(sql);

    if(!ok)
    {
        qDebug()<<"Cpp:更新数据失败";
    }
    else
    {
        qDebug()<<"Cpp:更新数据成功";
    }
}

QString PL_ProcessDataManager::LeftAngle01() const
{
    return m_LeftAngle01;
}

void PL_ProcessDataManager::setLeftAngle01(const QString &newLeftAngle01)
{
    if (m_LeftAngle01 == newLeftAngle01)
        return;
    m_LeftAngle01 = newLeftAngle01;
    emit LeftAngle01Changed();
}

QString PL_ProcessDataManager::RightAngle01() const
{
    return m_RightAngle01;
}

void PL_ProcessDataManager::setRightAngle01(const QString &newRightAngle01)
{
    if (m_RightAngle01 == newRightAngle01)
        return;
    m_RightAngle01 = newRightAngle01;
    emit RightAngle01Changed();
}

QString PL_ProcessDataManager::LG_Value01() const
{
    return m_LG_Value01;
}

void PL_ProcessDataManager::setLG_Value01(const QString &newLG_Value01)
{
    if (m_LG_Value01 == newLG_Value01)
        return;
    m_LG_Value01 = newLG_Value01;
    emit LG_Value01Changed();
}

QString PL_ProcessDataManager::LC_Value01() const
{
    return m_LC_Value01;
}

void PL_ProcessDataManager::setLC_Value01(const QString &newLC_Value01)
{
    if (m_LC_Value01 == newLC_Value01)
        return;
    m_LC_Value01 = newLC_Value01;
    emit LC_Value01Changed();
}

QString PL_ProcessDataManager::Count01() const
{
    return m_Count01;
}

void PL_ProcessDataManager::setCount01(const QString &newCount01)
{
    if (m_Count01 == newCount01)
        return;
    m_Count01 = newCount01;
    emit Count01Changed();
}

QString PL_ProcessDataManager::LeftAngle02() const
{
    return m_LeftAngle02;
}

void PL_ProcessDataManager::setLeftAngle02(const QString &newLeftAngle02)
{
    if (m_LeftAngle02 == newLeftAngle02)
        return;
    m_LeftAngle02 = newLeftAngle02;
    emit LeftAngle02Changed();
}

QString PL_ProcessDataManager::RightAngle02() const
{
    return m_RightAngle02;
}

void PL_ProcessDataManager::setRightAngle02(const QString &newRightAngle02)
{
    if (m_RightAngle02 == newRightAngle02)
        return;
    m_RightAngle02 = newRightAngle02;
    emit RightAngle02Changed();
}

QString PL_ProcessDataManager::LG_Value02() const
{
    return m_LG_Value02;
}

void PL_ProcessDataManager::setLG_Value02(const QString &newLG_Value02)
{
    if (m_LG_Value02 == newLG_Value02)
        return;
    m_LG_Value02 = newLG_Value02;
    emit LG_Value02Changed();
}

QString PL_ProcessDataManager::LC_Value02() const
{
    return m_LC_Value02;
}

void PL_ProcessDataManager::setLC_Value02(const QString &newLC_Value02)
{
    if (m_LC_Value02 == newLC_Value02)
        return;
    m_LC_Value02 = newLC_Value02;
    emit LC_Value02Changed();
}

QString PL_ProcessDataManager::Count02() const
{
    return m_Count02;
}

void PL_ProcessDataManager::setCount02(const QString &newCount02)
{
    if (m_Count02 == newCount02)
        return;
    m_Count02 = newCount02;
    emit Count02Changed();
}

QString PL_ProcessDataManager::LeftAngle03() const
{
    return m_LeftAngle03;
}

void PL_ProcessDataManager::setLeftAngle03(const QString &newLeftAngle03)
{
    if (m_LeftAngle03 == newLeftAngle03)
        return;
    m_LeftAngle03 = newLeftAngle03;
    emit LeftAngle03Changed();
}

QString PL_ProcessDataManager::RightAngle03() const
{
    return m_RightAngle03;
}

void PL_ProcessDataManager::setRightAngle03(const QString &newRightAngle03)
{
    if (m_RightAngle03 == newRightAngle03)
        return;
    m_RightAngle03 = newRightAngle03;
    emit RightAngle03Changed();
}

QString PL_ProcessDataManager::LG_Value03() const
{
    return m_LG_Value03;
}

void PL_ProcessDataManager::setLG_Value03(const QString &newLG_Value03)
{
    if (m_LG_Value03 == newLG_Value03)
        return;
    m_LG_Value03 = newLG_Value03;
    emit LG_Value03Changed();
}

QString PL_ProcessDataManager::LC_Value03() const
{
    return m_LC_Value03;
}

void PL_ProcessDataManager::setLC_Value03(const QString &newLC_Value03)
{
    if (m_LC_Value03 == newLC_Value03)
        return;
    m_LC_Value03 = newLC_Value03;
    emit LC_Value03Changed();
}

QString PL_ProcessDataManager::Count03() const
{
    return m_Count03;
}

void PL_ProcessDataManager::setCount03(const QString &newCount03)
{
    if (m_Count03 == newCount03)
        return;
    m_Count03 = newCount03;
    emit Count03Changed();
}

QString PL_ProcessDataManager::LeftAngle04() const
{
    return m_LeftAngle04;
}

void PL_ProcessDataManager::setLeftAngle04(const QString &newLeftAngle04)
{
    if (m_LeftAngle04 == newLeftAngle04)
        return;
    m_LeftAngle04 = newLeftAngle04;
    emit LeftAngle04Changed();
}

QString PL_ProcessDataManager::RightAngle04() const
{
    return m_RightAngle04;
}

void PL_ProcessDataManager::setRightAngle04(const QString &newRightAngle04)
{
    if (m_RightAngle04 == newRightAngle04)
        return;
    m_RightAngle04 = newRightAngle04;
    emit RightAngle04Changed();
}

QString PL_ProcessDataManager::LG_Value04() const
{
    return m_LG_Value04;
}

void PL_ProcessDataManager::setLG_Value04(const QString &newLG_Value04)
{
    if (m_LG_Value04 == newLG_Value04)
        return;
    m_LG_Value04 = newLG_Value04;
    emit LG_Value04Changed();
}

QString PL_ProcessDataManager::LC_Value04() const
{
    return m_LC_Value04;
}

void PL_ProcessDataManager::setLC_Value04(const QString &newLC_Value04)
{
    if (m_LC_Value04 == newLC_Value04)
        return;
    m_LC_Value04 = newLC_Value04;
    emit LC_Value04Changed();
}

QString PL_ProcessDataManager::Count04() const
{
    return m_Count04;
}

void PL_ProcessDataManager::setCount04(const QString &newCount04)
{
    if (m_Count04 == newCount04)
        return;
    m_Count04 = newCount04;
    emit Count04Changed();
}

QString PL_ProcessDataManager::LeftAngle05() const
{
    return m_LeftAngle05;
}

void PL_ProcessDataManager::setLeftAngle05(const QString &newLeftAngle05)
{
    if (m_LeftAngle05 == newLeftAngle05)
        return;
    m_LeftAngle05 = newLeftAngle05;
    emit LeftAngle05Changed();
}

QString PL_ProcessDataManager::RightAngle05() const
{
    return m_RightAngle05;
}

void PL_ProcessDataManager::setRightAngle05(const QString &newRightAngle05)
{
    if (m_RightAngle05 == newRightAngle05)
        return;
    m_RightAngle05 = newRightAngle05;
    emit RightAngle05Changed();
}

QString PL_ProcessDataManager::LG_Value05() const
{
    return m_LG_Value05;
}

void PL_ProcessDataManager::setLG_Value05(const QString &newLG_Value05)
{
    if (m_LG_Value05 == newLG_Value05)
        return;
    m_LG_Value05 = newLG_Value05;
    emit LG_Value05Changed();
}

QString PL_ProcessDataManager::LC_Value05() const
{
    return m_LC_Value05;
}

void PL_ProcessDataManager::setLC_Value05(const QString &newLC_Value05)
{
    if (m_LC_Value05 == newLC_Value05)
        return;
    m_LC_Value05 = newLC_Value05;
    emit LC_Value05Changed();
}

QString PL_ProcessDataManager::Count05() const
{
    return m_Count05;
}

void PL_ProcessDataManager::setCount05(const QString &newCount05)
{
    if (m_Count05 == newCount05)
        return;
    m_Count05 = newCount05;
    emit Count05Changed();
}

QString PL_ProcessDataManager::LeftAngle06() const
{
    return m_LeftAngle06;
}

void PL_ProcessDataManager::setLeftAngle06(const QString &newLeftAngle06)
{
    if (m_LeftAngle06 == newLeftAngle06)
        return;
    m_LeftAngle06 = newLeftAngle06;
    emit LeftAngle06Changed();
}

QString PL_ProcessDataManager::RightAngle06() const
{
    return m_RightAngle06;
}

void PL_ProcessDataManager::setRightAngle06(const QString &newRightAngle06)
{
    if (m_RightAngle06 == newRightAngle06)
        return;
    m_RightAngle06 = newRightAngle06;
    emit RightAngle06Changed();
}

QString PL_ProcessDataManager::LG_Value06() const
{
    return m_LG_Value06;
}

void PL_ProcessDataManager::setLG_Value06(const QString &newLG_Value06)
{
    if (m_LG_Value06 == newLG_Value06)
        return;
    m_LG_Value06 = newLG_Value06;
    emit LG_Value06Changed();
}

QString PL_ProcessDataManager::LC_Value06() const
{
    return m_LC_Value06;
}

void PL_ProcessDataManager::setLC_Value06(const QString &newLC_Value06)
{
    if (m_LC_Value06 == newLC_Value06)
        return;
    m_LC_Value06 = newLC_Value06;
    emit LC_Value06Changed();
}

QString PL_ProcessDataManager::Count06() const
{
    return m_Count06;
}

void PL_ProcessDataManager::setCount06(const QString &newCount06)
{
    if (m_Count06 == newCount06)
        return;
    m_Count06 = newCount06;
    emit Count06Changed();
}

QString PL_ProcessDataManager::LeftAngle07() const
{
    return m_LeftAngle07;
}

void PL_ProcessDataManager::setLeftAngle07(const QString &newLeftAngle07)
{
    if (m_LeftAngle07 == newLeftAngle07)
        return;
    m_LeftAngle07 = newLeftAngle07;
    emit LeftAngle07Changed();
}

QString PL_ProcessDataManager::RightAngle07() const
{
    return m_RightAngle07;
}

void PL_ProcessDataManager::setRightAngle07(const QString &newRightAngle07)
{
    if (m_RightAngle07 == newRightAngle07)
        return;
    m_RightAngle07 = newRightAngle07;
    emit RightAngle07Changed();
}

QString PL_ProcessDataManager::LG_Value07() const
{
    return m_LG_Value07;
}

void PL_ProcessDataManager::setLG_Value07(const QString &newLG_Value07)
{
    if (m_LG_Value07 == newLG_Value07)
        return;
    m_LG_Value07 = newLG_Value07;
    emit LG_Value07Changed();
}

QString PL_ProcessDataManager::LC_Value07() const
{
    return m_LC_Value07;
}

void PL_ProcessDataManager::setLC_Value07(const QString &newLC_Value07)
{
    if (m_LC_Value07 == newLC_Value07)
        return;
    m_LC_Value07 = newLC_Value07;
    emit LC_Value07Changed();
}

QString PL_ProcessDataManager::Count07() const
{
    return m_Count07;
}

void PL_ProcessDataManager::setCount07(const QString &newCount07)
{
    if (m_Count07 == newCount07)
        return;
    m_Count07 = newCount07;
    emit Count07Changed();
}

QString PL_ProcessDataManager::LeftAngle08() const
{
    return m_LeftAngle08;
}

void PL_ProcessDataManager::setLeftAngle08(const QString &newLeftAngle08)
{
    if (m_LeftAngle08 == newLeftAngle08)
        return;
    m_LeftAngle08 = newLeftAngle08;
    emit LeftAngle08Changed();
}

QString PL_ProcessDataManager::RightAngle08() const
{
    return m_RightAngle08;
}

void PL_ProcessDataManager::setRightAngle08(const QString &newRightAngle08)
{
    if (m_RightAngle08 == newRightAngle08)
        return;
    m_RightAngle08 = newRightAngle08;
    emit RightAngle08Changed();
}

QString PL_ProcessDataManager::LG_Value08() const
{
    return m_LG_Value08;
}

void PL_ProcessDataManager::setLG_Value08(const QString &newLG_Value08)
{
    if (m_LG_Value08 == newLG_Value08)
        return;
    m_LG_Value08 = newLG_Value08;
    emit LG_Value08Changed();
}

QString PL_ProcessDataManager::LC_Value08() const
{
    return m_LC_Value08;
}

void PL_ProcessDataManager::setLC_Value08(const QString &newLC_Value08)
{
    if (m_LC_Value08 == newLC_Value08)
        return;
    m_LC_Value08 = newLC_Value08;
    emit LC_Value08Changed();
}

QString PL_ProcessDataManager::Count08() const
{
    return m_Count08;
}

void PL_ProcessDataManager::setCount08(const QString &newCount08)
{
    if (m_Count08 == newCount08)
        return;
    m_Count08 = newCount08;
    emit Count08Changed();
}

QString PL_ProcessDataManager::LeftAngle09() const
{
    return m_LeftAngle09;
}

void PL_ProcessDataManager::setLeftAngle09(const QString &newLeftAngle09)
{
    if (m_LeftAngle09 == newLeftAngle09)
        return;
    m_LeftAngle09 = newLeftAngle09;
    emit LeftAngle09Changed();
}

QString PL_ProcessDataManager::RightAngle09() const
{
    return m_RightAngle09;
}

void PL_ProcessDataManager::setRightAngle09(const QString &newRightAngle09)
{
    if (m_RightAngle09 == newRightAngle09)
        return;
    m_RightAngle09 = newRightAngle09;
    emit RightAngle09Changed();
}

QString PL_ProcessDataManager::LG_Value09() const
{
    return m_LG_Value09;
}

void PL_ProcessDataManager::setLG_Value09(const QString &newLG_Value09)
{
    if (m_LG_Value09 == newLG_Value09)
        return;
    m_LG_Value09 = newLG_Value09;
    emit LG_Value09Changed();
}

QString PL_ProcessDataManager::LC_Value09() const
{
    return m_LC_Value09;
}

void PL_ProcessDataManager::setLC_Value09(const QString &newLC_Value09)
{
    if (m_LC_Value09 == newLC_Value09)
        return;
    m_LC_Value09 = newLC_Value09;
    emit LC_Value09Changed();
}

QString PL_ProcessDataManager::Count09() const
{
    return m_Count09;
}

void PL_ProcessDataManager::setCount09(const QString &newCount09)
{
    if (m_Count09 == newCount09)
        return;
    m_Count09 = newCount09;
    emit Count09Changed();
}

QString PL_ProcessDataManager::LeftAngle10() const
{
    return m_LeftAngle10;
}

void PL_ProcessDataManager::setLeftAngle10(const QString &newLeftAngle10)
{
    if (m_LeftAngle10 == newLeftAngle10)
        return;
    m_LeftAngle10 = newLeftAngle10;
    emit LeftAngle10Changed();
}

QString PL_ProcessDataManager::RightAngle10() const
{
    return m_RightAngle10;
}

void PL_ProcessDataManager::setRightAngle10(const QString &newRightAngle10)
{
    if (m_RightAngle10 == newRightAngle10)
        return;
    m_RightAngle10 = newRightAngle10;
    emit RightAngle10Changed();
}

QString PL_ProcessDataManager::LG_Value10() const
{
    return m_LG_Value10;
}

void PL_ProcessDataManager::setLG_Value10(const QString &newLG_Value10)
{
    if (m_LG_Value10 == newLG_Value10)
        return;
    m_LG_Value10 = newLG_Value10;
    emit LG_Value10Changed();
}

QString PL_ProcessDataManager::LC_Value10() const
{
    return m_LC_Value10;
}

void PL_ProcessDataManager::setLC_Value10(const QString &newLC_Value10)
{
    if (m_LC_Value10 == newLC_Value10)
        return;
    m_LC_Value10 = newLC_Value10;
    emit LC_Value10Changed();
}

QString PL_ProcessDataManager::Count10() const
{
    return m_Count10;
}

void PL_ProcessDataManager::setCount10(const QString &newCount10)
{
    if (m_Count10 == newCount10)
        return;
    m_Count10 = newCount10;
    emit Count10Changed();
}

QString PL_ProcessDataManager::LeftAngle11() const
{
    return m_LeftAngle11;
}

void PL_ProcessDataManager::setLeftAngle11(const QString &newLeftAngle11)
{
    if (m_LeftAngle11 == newLeftAngle11)
        return;
    m_LeftAngle11 = newLeftAngle11;
    emit LeftAngle11Changed();
}

QString PL_ProcessDataManager::RightAngle11() const
{
    return m_RightAngle11;
}

void PL_ProcessDataManager::setRightAngle11(const QString &newRightAngle11)
{
    if (m_RightAngle11 == newRightAngle11)
        return;
    m_RightAngle11 = newRightAngle11;
    emit RightAngle11Changed();
}

QString PL_ProcessDataManager::LG_Value11() const
{
    return m_LG_Value11;
}

void PL_ProcessDataManager::setLG_Value11(const QString &newLG_Value11)
{
    if (m_LG_Value11 == newLG_Value11)
        return;
    m_LG_Value11 = newLG_Value11;
    emit LG_Value11Changed();
}

QString PL_ProcessDataManager::LC_Value11() const
{
    return m_LC_Value11;
}

void PL_ProcessDataManager::setLC_Value11(const QString &newLC_Value11)
{
    if (m_LC_Value11 == newLC_Value11)
        return;
    m_LC_Value11 = newLC_Value11;
    emit LC_Value11Changed();
}

QString PL_ProcessDataManager::Count11() const
{
    return m_Count11;
}

void PL_ProcessDataManager::setCount11(const QString &newCount11)
{
    if (m_Count11 == newCount11)
        return;
    m_Count11 = newCount11;
    emit Count11Changed();
}

QString PL_ProcessDataManager::LeftAngle12() const
{
    return m_LeftAngle12;
}

void PL_ProcessDataManager::setLeftAngle12(const QString &newLeftAngle12)
{
    if (m_LeftAngle12 == newLeftAngle12)
        return;
    m_LeftAngle12 = newLeftAngle12;
    emit LeftAngle12Changed();
}

QString PL_ProcessDataManager::RightAngle12() const
{
    return m_RightAngle12;
}

void PL_ProcessDataManager::setRightAngle12(const QString &newRightAngle12)
{
    if (m_RightAngle12 == newRightAngle12)
        return;
    m_RightAngle12 = newRightAngle12;
    emit RightAngle12Changed();
}

QString PL_ProcessDataManager::LG_Value12() const
{
    return m_LG_Value12;
}

void PL_ProcessDataManager::setLG_Value12(const QString &newLG_Value12)
{
    if (m_LG_Value12 == newLG_Value12)
        return;
    m_LG_Value12 = newLG_Value12;
    emit LG_Value12Changed();
}

QString PL_ProcessDataManager::LC_Value12() const
{
    return m_LC_Value12;
}

void PL_ProcessDataManager::setLC_Value12(const QString &newLC_Value12)
{
    if (m_LC_Value12 == newLC_Value12)
        return;
    m_LC_Value12 = newLC_Value12;
    emit LC_Value12Changed();
}

QString PL_ProcessDataManager::Count12() const
{
    return m_Count12;
}

void PL_ProcessDataManager::setCount12(const QString &newCount12)
{
    if (m_Count12 == newCount12)
        return;
    m_Count12 = newCount12;
    emit Count12Changed();
}

QString PL_ProcessDataManager::LeftAngle13() const
{
    return m_LeftAngle13;
}

void PL_ProcessDataManager::setLeftAngle13(const QString &newLeftAngle13)
{
    if (m_LeftAngle13 == newLeftAngle13)
        return;
    m_LeftAngle13 = newLeftAngle13;
    emit LeftAngle13Changed();
}

QString PL_ProcessDataManager::RightAngle13() const
{
    return m_RightAngle13;
}

void PL_ProcessDataManager::setRightAngle13(const QString &newRightAngle13)
{
    if (m_RightAngle13 == newRightAngle13)
        return;
    m_RightAngle13 = newRightAngle13;
    emit RightAngle13Changed();
}

QString PL_ProcessDataManager::LG_Value13() const
{
    return m_LG_Value13;
}

void PL_ProcessDataManager::setLG_Value13(const QString &newLG_Value13)
{
    if (m_LG_Value13 == newLG_Value13)
        return;
    m_LG_Value13 = newLG_Value13;
    emit LG_Value13Changed();
}

QString PL_ProcessDataManager::LC_Value13() const
{
    return m_LC_Value13;
}

void PL_ProcessDataManager::setLC_Value13(const QString &newLC_Value13)
{
    if (m_LC_Value13 == newLC_Value13)
        return;
    m_LC_Value13 = newLC_Value13;
    emit LC_Value13Changed();
}

QString PL_ProcessDataManager::Count13() const
{
    return m_Count13;
}

void PL_ProcessDataManager::setCount13(const QString &newCount13)
{
    if (m_Count13 == newCount13)
        return;
    m_Count13 = newCount13;
    emit Count13Changed();
}

QString PL_ProcessDataManager::LeftAngle14() const
{
    return m_LeftAngle14;
}

void PL_ProcessDataManager::setLeftAngle14(const QString &newLeftAngle14)
{
    if (m_LeftAngle14 == newLeftAngle14)
        return;
    m_LeftAngle14 = newLeftAngle14;
    emit LeftAngle14Changed();
}

QString PL_ProcessDataManager::RightAngle14() const
{
    return m_RightAngle14;
}

void PL_ProcessDataManager::setRightAngle14(const QString &newRightAngle14)
{
    if (m_RightAngle14 == newRightAngle14)
        return;
    m_RightAngle14 = newRightAngle14;
    emit RightAngle14Changed();
}

QString PL_ProcessDataManager::LG_Value14() const
{
    return m_LG_Value14;
}

void PL_ProcessDataManager::setLG_Value14(const QString &newLG_Value14)
{
    if (m_LG_Value14 == newLG_Value14)
        return;
    m_LG_Value14 = newLG_Value14;
    emit LG_Value14Changed();
}

QString PL_ProcessDataManager::LC_Value14() const
{
    return m_LC_Value14;
}

void PL_ProcessDataManager::setLC_Value14(const QString &newLC_Value14)
{
    if (m_LC_Value14 == newLC_Value14)
        return;
    m_LC_Value14 = newLC_Value14;
    emit LC_Value14Changed();
}

QString PL_ProcessDataManager::Count14() const
{
    return m_Count14;
}

void PL_ProcessDataManager::setCount14(const QString &newCount14)
{
    if (m_Count14 == newCount14)
        return;
    m_Count14 = newCount14;
    emit Count14Changed();
}

QString PL_ProcessDataManager::LeftAngle15() const
{
    return m_LeftAngle15;
}

void PL_ProcessDataManager::setLeftAngle15(const QString &newLeftAngle15)
{
    if (m_LeftAngle15 == newLeftAngle15)
        return;
    m_LeftAngle15 = newLeftAngle15;
    emit LeftAngle15Changed();
}

QString PL_ProcessDataManager::RightAngle15() const
{
    return m_RightAngle15;
}

void PL_ProcessDataManager::setRightAngle15(const QString &newRightAngle15)
{
    if (m_RightAngle15 == newRightAngle15)
        return;
    m_RightAngle15 = newRightAngle15;
    emit RightAngle15Changed();
}

QString PL_ProcessDataManager::LG_Value15() const
{
    return m_LG_Value15;
}

void PL_ProcessDataManager::setLG_Value15(const QString &newLG_Value15)
{
    if (m_LG_Value15 == newLG_Value15)
        return;
    m_LG_Value15 = newLG_Value15;
    emit LG_Value15Changed();
}

QString PL_ProcessDataManager::LC_Value15() const
{
    return m_LC_Value15;
}

void PL_ProcessDataManager::setLC_Value15(const QString &newLC_Value15)
{
    if (m_LC_Value15 == newLC_Value15)
        return;
    m_LC_Value15 = newLC_Value15;
    emit LC_Value15Changed();
}

QString PL_ProcessDataManager::Count15() const
{
    return m_Count15;
}

void PL_ProcessDataManager::setCount15(const QString &newCount15)
{
    if (m_Count15 == newCount15)
        return;
    m_Count15 = newCount15;
    emit Count15Changed();
}

QString PL_ProcessDataManager::LeftAngle16() const
{
    return m_LeftAngle16;
}

void PL_ProcessDataManager::setLeftAngle16(const QString &newLeftAngle16)
{
    if (m_LeftAngle16 == newLeftAngle16)
        return;
    m_LeftAngle16 = newLeftAngle16;
    emit LeftAngle16Changed();
}

QString PL_ProcessDataManager::RightAngle16() const
{
    return m_RightAngle16;
}

void PL_ProcessDataManager::setRightAngle16(const QString &newRightAngle16)
{
    if (m_RightAngle16 == newRightAngle16)
        return;
    m_RightAngle16 = newRightAngle16;
    emit RightAngle16Changed();
}

QString PL_ProcessDataManager::LG_Value16() const
{
    return m_LG_Value16;
}

void PL_ProcessDataManager::setLG_Value16(const QString &newLG_Value16)
{
    if (m_LG_Value16 == newLG_Value16)
        return;
    m_LG_Value16 = newLG_Value16;
    emit LG_Value16Changed();
}

QString PL_ProcessDataManager::LC_Value16() const
{
    return m_LC_Value16;
}

void PL_ProcessDataManager::setLC_Value16(const QString &newLC_Value16)
{
    if (m_LC_Value16 == newLC_Value16)
        return;
    m_LC_Value16 = newLC_Value16;
    emit LC_Value16Changed();
}

QString PL_ProcessDataManager::Count16() const
{
    return m_Count16;
}

void PL_ProcessDataManager::setCount16(const QString &newCount16)
{
    if (m_Count16 == newCount16)
        return;
    m_Count16 = newCount16;
    emit Count16Changed();
}

QString PL_ProcessDataManager::LeftAngle17() const
{
    return m_LeftAngle17;
}

void PL_ProcessDataManager::setLeftAngle17(const QString &newLeftAngle17)
{
    if (m_LeftAngle17 == newLeftAngle17)
        return;
    m_LeftAngle17 = newLeftAngle17;
    emit LeftAngle17Changed();
}

QString PL_ProcessDataManager::RightAngle17() const
{
    return m_RightAngle17;
}

void PL_ProcessDataManager::setRightAngle17(const QString &newRightAngle17)
{
    if (m_RightAngle17 == newRightAngle17)
        return;
    m_RightAngle17 = newRightAngle17;
    emit RightAngle17Changed();
}

QString PL_ProcessDataManager::LG_Value17() const
{
    return m_LG_Value17;
}

void PL_ProcessDataManager::setLG_Value17(const QString &newLG_Value17)
{
    if (m_LG_Value17 == newLG_Value17)
        return;
    m_LG_Value17 = newLG_Value17;
    emit LG_Value17Changed();
}

QString PL_ProcessDataManager::LC_Value17() const
{
    return m_LC_Value17;
}

void PL_ProcessDataManager::setLC_Value17(const QString &newLC_Value17)
{
    if (m_LC_Value17 == newLC_Value17)
        return;
    m_LC_Value17 = newLC_Value17;
    emit LC_Value17Changed();
}

QString PL_ProcessDataManager::Count17() const
{
    return m_Count17;
}

void PL_ProcessDataManager::setCount17(const QString &newCount17)
{
    if (m_Count17 == newCount17)
        return;
    m_Count17 = newCount17;
    emit Count17Changed();
}

QString PL_ProcessDataManager::LeftAngle18() const
{
    return m_LeftAngle18;
}

void PL_ProcessDataManager::setLeftAngle18(const QString &newLeftAngle18)
{
    if (m_LeftAngle18 == newLeftAngle18)
        return;
    m_LeftAngle18 = newLeftAngle18;
    emit LeftAngle18Changed();
}

QString PL_ProcessDataManager::RightAngle18() const
{
    return m_RightAngle18;
}

void PL_ProcessDataManager::setRightAngle18(const QString &newRightAngle18)
{
    if (m_RightAngle18 == newRightAngle18)
        return;
    m_RightAngle18 = newRightAngle18;
    emit RightAngle18Changed();
}

QString PL_ProcessDataManager::LG_Value18() const
{
    return m_LG_Value18;
}

void PL_ProcessDataManager::setLG_Value18(const QString &newLG_Value18)
{
    if (m_LG_Value18 == newLG_Value18)
        return;
    m_LG_Value18 = newLG_Value18;
    emit LG_Value18Changed();
}

QString PL_ProcessDataManager::LC_Value18() const
{
    return m_LC_Value18;
}

void PL_ProcessDataManager::setLC_Value18(const QString &newLC_Value18)
{
    if (m_LC_Value18 == newLC_Value18)
        return;
    m_LC_Value18 = newLC_Value18;
    emit LC_Value18Changed();
}

QString PL_ProcessDataManager::Count18() const
{
    return m_Count18;
}

void PL_ProcessDataManager::setCount18(const QString &newCount18)
{
    if (m_Count18 == newCount18)
        return;
    m_Count18 = newCount18;
    emit Count18Changed();
}

QString PL_ProcessDataManager::LeftAngle19() const
{
    return m_LeftAngle19;
}

void PL_ProcessDataManager::setLeftAngle19(const QString &newLeftAngle19)
{
    if (m_LeftAngle19 == newLeftAngle19)
        return;
    m_LeftAngle19 = newLeftAngle19;
    emit LeftAngle19Changed();
}

QString PL_ProcessDataManager::RightAngle19() const
{
    return m_RightAngle19;
}

void PL_ProcessDataManager::setRightAngle19(const QString &newRightAngle19)
{
    if (m_RightAngle19 == newRightAngle19)
        return;
    m_RightAngle19 = newRightAngle19;
    emit RightAngle19Changed();
}

QString PL_ProcessDataManager::LG_Value19() const
{
    return m_LG_Value19;
}

void PL_ProcessDataManager::setLG_Value19(const QString &newLG_Value19)
{
    if (m_LG_Value19 == newLG_Value19)
        return;
    m_LG_Value19 = newLG_Value19;
    emit LG_Value19Changed();
}

QString PL_ProcessDataManager::LC_Value19() const
{
    return m_LC_Value19;
}

void PL_ProcessDataManager::setLC_Value19(const QString &newLC_Value19)
{
    if (m_LC_Value19 == newLC_Value19)
        return;
    m_LC_Value19 = newLC_Value19;
    emit LC_Value19Changed();
}

QString PL_ProcessDataManager::Count19() const
{
    return m_Count19;
}

void PL_ProcessDataManager::setCount19(const QString &newCount19)
{
    if (m_Count19 == newCount19)
        return;
    m_Count19 = newCount19;
    emit Count19Changed();
}

QString PL_ProcessDataManager::LeftAngle20() const
{
    return m_LeftAngle20;
}

void PL_ProcessDataManager::setLeftAngle20(const QString &newLeftAngle20)
{
    if (m_LeftAngle20 == newLeftAngle20)
        return;
    m_LeftAngle20 = newLeftAngle20;
    emit LeftAngle20Changed();
}

QString PL_ProcessDataManager::RightAngle20() const
{
    return m_RightAngle20;
}

void PL_ProcessDataManager::setRightAngle20(const QString &newRightAngle20)
{
    if (m_RightAngle20 == newRightAngle20)
        return;
    m_RightAngle20 = newRightAngle20;
    emit RightAngle20Changed();
}

QString PL_ProcessDataManager::LG_Value20() const
{
    return m_LG_Value20;
}

void PL_ProcessDataManager::setLG_Value20(const QString &newLG_Value20)
{
    if (m_LG_Value20 == newLG_Value20)
        return;
    m_LG_Value20 = newLG_Value20;
    emit LG_Value20Changed();
}

QString PL_ProcessDataManager::LC_Value20() const
{
    return m_LC_Value20;
}

void PL_ProcessDataManager::setLC_Value20(const QString &newLC_Value20)
{
    if (m_LC_Value20 == newLC_Value20)
        return;
    m_LC_Value20 = newLC_Value20;
    emit LC_Value20Changed();
}

QString PL_ProcessDataManager::Count20() const
{
    return m_Count20;
}

void PL_ProcessDataManager::setCount20(const QString &newCount20)
{
    if (m_Count20 == newCount20)
        return;
    m_Count20 = newCount20;
    emit Count20Changed();
}
